import sys 
input = sys.stdin.readline

#1. 입력 변수 + 오름차순 정렬
N , C  = map(int, input().split())
arr =sorted([int(input()) for _ in range(N)])

#2. “최소 거리 dist”의 탐색 범위 초기화 # 이진 탐색
start = 1 ; end = arr[-1] - arr[0] 
answer = 0  # 최소 거리 중 최대 거리 

#3.최소 인접 거리 dist 최대값 찾기
#설치 공유기는 dist이상의 간격으로 설치
while start <= end : 
  mid = (start+end)//2
  cnt = 1 # arr[0]은 설치 시작점
  
  #[1] 최소 인접 거리가 mid 이상으로 "최대 설치 가능 공유기 개수계산"
  prev = arr[0] # 이전에 설치한 공유기 위치
  for i in range(1,N) :
    if arr[i] - prev >= mid : # 공유기 등록
      prev = arr[i]
      cnt+=1 
    # 공유기 등록하기엔 dist부족한 경우 -> 다음 arr로 이동 

  #[2] 최소거리 dist 이분 탐색
  # 조건 : 설치한 공유기 개수 Cnt 가 C 이상
  # True 경우 ,  최소거리 Answer 업데이트, 탐색 범위 (mid+1 : end) 이동
  if cnt >= C :
    answer = max(answer ,mid)
    start = mid+1
  # False 경우: 탐색 범위 Lower bound로 이동(start : mid)
  else : 
    end = mid - 1

print(answer)

K, N = map(int, input().split())

lines = [int(input()) for _ in range(K)]
# 1. 범위 초기화
start = 1
end = max(lines)
#2. 이분 탐색
while start <= end:
    mid = (start + end) // 2
    cnt = 0
    for line in lines:
        cnt += line // mid

    if cnt < N:
        end = mid - 1
    else:
        start = mid + 1

print(end)

"""
#문제 다 읽고 수도 코드 짜자
- goal) 시작 R => 목표 G 까지 최소 이동 수 구하기(도달 못하면 -1 )
- 상하좌우로 "장애물, 가장자리"에 부딫칠 떄까지 이동 = 1회 이동 => 외곽& 장애물 = field[-1]
- board 는 text로 주어짐 => 2차원 배열로 변환 
# flow - BFS : 최단 거리
- 이동 방법
"""
from collections import deque
INF = 1e9
def solution(board):
    answer = 0
    #1. 필드 board 정보를 2차원 배열로 변환(장애물 -1/ 없음 0 )
    N , M = len(board) , len(board[0])
    field = [[INF]*M for _ in range(N)]
    
    for i in range(N) :
        for j in range(M) :
            if board[i][j] == "R":
                start = [i,j]
            elif board[i][j] == "G":
                target = [i,j]
            elif board[i][j] == "D":
                field[i][j] = -1
                # print("break",field[i][j])
    #2. 탐색 
    # print(start , target ,field)
    #상하좌우
    dy = [-1, 1, 0,0] 
    dx = [0,0,-1,1]
    def move_node(d, start): # 이동 방향 ,출발점
        ny , nx = start ; flag = False # flag : 최소 이동 여부(Y/N)
        while 0<= ny + dy[d]< N and 0<= nx+dx[d] < M and field[ny + dy[d]][nx+dx[d]] >= 0 : # 장애물, 가장자리x 
            ny += dy[d] ; nx += dx[d]
            flag = True
        return ny ,nx , flag
    # 시작점 초기화
    q= deque([start])
    field[start[0]][start[1]] = 0 
    cnt = 0 
    while q : 
        cy,cx = q.popleft()
        if [cy,cx] == target : #(옵션)효율성
            break)
        for di in range(4):
            cnt += 1 
            ny,nx,f = move_node(di, [cy,cx])
            if f and field[ny][nx] == INF : # 해당 [ny,nx] 에 처음 도착(방문x) & 해당 지점에 이동 가능할 경우 
                field[ny][nx] = min(field[ny][nx], field[cy][cx]+1)
                # min은 필요 없음(BFS로 가장먼저 field에 입력 된 턴수가 최소 이동수 )
                # field안에 최소 이동 턴수 기록
                q.append([ny,nx])

    #3. 출력
    answer=field[target[0]][target[1]]
    # target지점 값에 업데이트가 없음 -> 도달 못함 : -1 / 최소 이동 턴수
    if answer >= INF : 
        answer = -1
    return answer

def solution(k, dungeons):
    max_count = 0 
    def brutefoce(path, life):
        nonlocal max_count 
        for idx in range(len(dungeons)):
            # (유망 여부) 조건에 안 맞으면 건너뛰기 : limit 제한 , 중복 탐사 방지
            if dungeons[idx][0] <= life and  idx not in path:
                # 3. 탐색할 노드 선택 - 상태 변화  
                path.append(idx)
                # 4. 재귀 호출(담 단계) - 자식 노드로 이동
                brutefoce(path ,life -dungeons[idx][1])
                # 5. 선택 취소 - 부모 노드로 복귀
                path.pop()
        max_count = max(max_count , len(path))
    brutefoce([], k )

    return max_count

def solution(s):
    answer = []
    # 1. 문자열 속 모든 "0" 제외하기 & 제외한 0 개수 누적 합
    # 2. 남은 문자열 크기의 값을 이진수 변환 
    #3. 변환된 이진수를 다시 [1]번의 입력으로 넣어 반복(문자열 길이가 1이 될때 까지) 
    
    a = 0 
    rotate = 0 
    while len(s) > 1 :
        cnt = 0
        for n in s : 
            if n == "0" :
                a+=1
                continue
            cnt +=1

        s= str(bin(cnt))[2:]
        rotate += 1
    
    answer = [rotate , a]
    return answer